home *** CD-ROM | disk | FTP | other *** search
/ Programming Sound Cards / Programming Sound Cards.iso / sound_52 / bendlib.ma < prev    next >
Text File  |  1995-01-01  |  17KB  |  598 lines
  1. #
  2. # bendlib.ma - (dx7) pitch bend library of Ravel routines
  3. #
  4. # Implementation Assumptions:
  5. #
  6. # 1. Setup for dx7 type instrument.
  7. # might work elsewhere as is but may take some changes.
  8. #
  9. # 2. check SEMITONEUNITS; i.e., no of pitch bend
  10. # units per semitone. We set poff to 1.
  11. #
  12. # 3. Assume that
  13. # dx7 is setup as follows:
  14. #    range 12 (an octave span for the bend)
  15. #    step 0 - continuous bend (not semitones)
  16. #
  17. # Functions supported:
  18. ##############################################################
  19. # 1. riff bendUp(firstNote, firstTime, bendTime, totalTime, interval, velocity, vibrattoFlag, vibrattoSteps)
  20. #    pitch bend up of interval of 1-12 semitones
  21. # 2. riff bendDown(firstNote, firstTime, bendTime, totalTime, interval, velocity, vibrattoFlag, vibrattoSteps)
  22. #    pitch bend down of interval of 1-12 semitones
  23. # 3. riff bendUpDown(firstNote, firstTime, bendTime, totalTime, interval, velocity, vibrattoFlag, vibrattoSteps)
  24. #    pitch bend up then down 
  25. # 4. riff vibratto(note, bendTime, totalTime, vibrattoStep, velocity)
  26. #    vibrato on specified note
  27. #
  28. # There are also some test routines.
  29. # They are at the bottom of the module. They are setup as riffs.
  30. # They can function as examples of how to use the above riffs.
  31.  
  32.  
  33. # bend units per semi-tone 
  34. SEMITONEUNITS = 680
  35. # bend units per whole-tone 
  36. WHOLETONEUNITS = 1360
  37. # bend units at pitchbend center
  38. BENDCENTER = 8192
  39.  
  40. #
  41. # vibratto - play vibratto around requested tone.
  42. #
  43. # time is broken up into two parts, bendTime and remainder.
  44. # bendTime comes first. This permits vibratto followed by
  45. # normal non-vibratto tone.
  46. #
  47. # vibrattoStep - range of bend around center tone.
  48. #    10 - minimum
  49. #    60 - medium
  50. #    100 - heavy
  51. # 
  52. riff vibratto(firstNote, bendTime, totalTime, vibrattoStep, velocity)
  53. # interval - number of semitones to bend up
  54.     int events
  55.     int bendIncrement
  56.     int curincrement
  57.     int bendvalue
  58.     int elapsedTime
  59.     int remainingTime
  60.  
  61.     # make sure pitch bend offset is set at 1 so
  62.     # that we use the true MIDI numbers in decimal
  63.     poff 1
  64.  
  65.     bendIncrement = vibrattoStep
  66.  
  67.     # play note with 0 eventime    
  68.     # the note lasts "totalTime" time before a noteoff
  69.     # is issued
  70.     note firstNote    0,totalTime        velocity
  71.  
  72.     bendvalue = BENDCENTER
  73.     # start off with pitch bend wheel centered
  74.     # take no time to do this
  75.     bend    0    BENDCENTER
  76.  
  77.     # loop through pitch bend up
  78.     elapsedTime = 0
  79.     for ( events = 0; events < bendTime; events++)
  80.         # alternate up/down around pitch
  81.         if ({events % 2} == 0)
  82.             bend 1 BENDCENTER+bendIncrement
  83.         else
  84.             bend 1 BENDCENTER-bendIncrement 
  85.         end
  86.         elapsedTime++
  87.     end
  88.     # issue another pitch bend to make sure we
  89.     # arrived where we want because for loop
  90.     # above may not have arrived precisely
  91.     bend 0    BENDCENTER 
  92.     # use bend constant to return pitchbend wheel to center
  93.     poff 1
  94.     # deterime amount of eventtime remaining
  95.     # we may have some slop if the amount of time
  96.     # spent playing bends did not equal the bendTime
  97.     if (elapsedTime == bendTime)
  98.         remainingTime = totalTime - bendTime
  99.     else
  100.         remainingTime = {bendTime - elapsedTime} + {totalTime - bendTime}
  101.     end
  102.     # tie note for remaining time
  103.     tie  remainingTime
  104. #     void printf("bend %d \n",BENDCENTER)
  105.     # issue rest to make sure noteoff in effect. this
  106.     # is paranoia most likely
  107.     rest 0
  108.     # put pitchbend wheel at center
  109.     bend 0 BENDCENTER
  110. #    void dumptime()
  111. end
  112.  
  113. #
  114. # vnonote - play vibratto around requested tone. Used
  115. #    by other bend routines. Does not issue initial note.
  116. #    Also assumes that we do pitch bend for entire totalTime.
  117. #    I.e., not broken up into pitch bend, no pitch bend step.
  118. #
  119. # vibrattoStep - range of bend around center tone.
  120. #    10 - minimum
  121. #    60 - medium
  122. #    100 - heavy
  123. # 
  124. riff vnonote(firstNote, curbend, totalTime, vibrattoStep, velocity)
  125. # interval - number of semitones to bend up
  126.     int events
  127.     int bendvalue
  128.     int bendIncrement
  129.     int elapsedTime
  130.     int remainingTime
  131.  
  132.     # make sure pitch bend offset is set at 1 so
  133.     # that we use the true MIDI numbers in decimal
  134.     poff 1
  135.  
  136.     bendIncrement = vibrattoStep
  137.  
  138.     bendvalue = curbend
  139.  
  140.     # loop through pitch bend up
  141.     for ( events = 0; events < totalTime; events++)
  142.         # alternate up/down around pitch
  143.         if ({events % 2} == 0)
  144.             bend 1 bendvalue+bendIncrement
  145.         else
  146.             bend 1 bendvalue-bendIncrement 
  147.         end
  148.     end
  149.     # issue another pitch bend to make sure we
  150.     # arrived where we want because for loop
  151.     # above may not have arrived precisely
  152.     bend 0    bendvalue 
  153.     # issue rest to make sure noteoff in effect. this
  154.     # is paranoia most likely
  155.     rest 0
  156. #    void dumptime()
  157.     bend 0 BENDCENTER
  158. end
  159.  
  160. #
  161. # bendUp according to specified interval.
  162. #
  163. # Eventtime is broken up according to following scheme.
  164. #
  165. #    1. issue note for firstTime events
  166. #    2. bend for bendTime events
  167. #    3. tie for remaining time (totalTime - (firstTime + bendTime)
  168. #    Latter non-bend time may have vibratto attached.
  169. #
  170. # e.g.,
  171. #    C, e, e, q, 2, 100, 0, 0 
  172. #
  173. # would mean play C for e events, then bend to D for e events,
  174. # and quit with no vibratto at end.
  175. #
  176. # firstnote - starting note
  177. # firstTime - time devoted to first note before bend
  178. # bendTime - period of time for bends
  179. # totalTime - total elapsed time for note to note. If totalTime
  180. #    is larger than bendTime, we do the pitch bend first
  181. #    and spend the remaining amount of time on the note.
  182. # interval - 1..12 semitones.
  183. # velocity - desired velocity.
  184. # vibratto - flag, 1 for TRUE, 0 for FALSE, if specified
  185. # then we use vibratto for last totalTime-bendTime period.
  186. # This permits more guitar-like effects.
  187. # vibrattoStep - how much pitch bend for vibratto
  188. #
  189. # bendUp(C, 0, h, w, 12, 100, 0, 0)
  190. # would execute a linear bend from C to HC for the first 'h'
  191. # of time, and then execute the HC for the 2nd 'h' with
  192. # total elapsed time of 'w'.
  193. #
  194. # Algorithm needs work but this gets the job done.
  195. #
  196.  
  197. riff bendUp(firstNote, firstTime, bendTime, totalTime, interval, velocity, vflag, vsteps)
  198. # interval - number of semitones to bend up
  199.     int events
  200.     int bendIncrement
  201.     int totalBendUnits
  202.     int pertimeClick
  203.     int curincrement
  204.     int bendvalue
  205.     int elapsedTime
  206.     int remainingTime
  207.  
  208.     # make sure pitch bend offset is set at 1 so
  209.     # that we use the true MIDI numbers in decimal
  210.     poff 1
  211.  
  212.     # don't set interval to 0
  213.     if (interval == 0)
  214.         void printf("bendUp: invalid 0 interval\n")
  215.         final
  216.     end
  217.     # total number of bend units to cover interval
  218.     totalBendUnits = interval * SEMITONEUNITS
  219.  
  220.     # determine per bend event time and how much
  221.     # to bend per bend call
  222.     # if more time than total bend units according
  223.     # to the interval, then divide the time
  224.     # by the number of bend units to get the per
  225.     # bend call time, otherwise time is 1
  226.     if (bendTime > totalBendUnits)
  227.         pertimeClick = bendTime / totalBendUnits
  228.         bendIncrement = totalBendUnits / pertimeClick
  229.     else
  230.         bendIncrement = totalBendUnits / bendTime
  231.         pertimeClick = 1
  232.     end
  233.  
  234. #     void printf("bendIncrement %d\n",bendIncrement)
  235. #     void printf("pertimeClick %d\n",pertimeClick)
  236. #     void printf("totalBendUnits %d\n",totalBendUnits)
  237.  
  238.     # play note with 0 eventime    
  239.     # the note lasts "totalTime" time before a noteoff
  240.     # is issued
  241.     note firstNote    firstTime,totalTime        velocity
  242. #    void dumptime()
  243.     bendvalue = BENDCENTER
  244.     # start off with pitch bend wheel centered
  245.     # take no time to do this
  246.     poff 1
  247.     bend    0    BENDCENTER
  248.     curincrement = bendIncrement
  249.     # loop through pitch bend up
  250.     elapsedTime = 0
  251.     for ( events = 0; events < bendTime; events++)
  252.         bend pertimeClick BENDCENTER+curincrement 
  253. #        void printf("%d %d\n",pertimeClick,BENDCENTER+curincrement)
  254.         curincrement = curincrement + bendIncrement
  255.         elapsedTime = elapsedTime + pertimeClick
  256.     end
  257.     # issue another pitch bend to make sure we
  258.     # arrived where we want because for loop
  259.     # above may not have arrived precisely
  260.     bend 0    BENDCENTER + totalBendUnits
  261.  
  262.  
  263.     # use bend constant to return pitchbend wheel to center
  264.     poff 1
  265.     # deterime amount of eventtime remaining
  266.     # we may have some slop if the amount of time
  267.     # spent playing bends did not equal the bendTime
  268.     if (elapsedTime == bendTime)
  269.         remainingTime = totalTime - {firstTime + bendTime}
  270.     else
  271.         remainingTime = {bendTime - elapsedTime} + {totalTime - {bendTime + firstTime}}
  272.     end
  273.     # do vibratto for last half
  274.     # use special vibratto routine that does not issue note
  275.     # just bends
  276.     if (vflag)
  277.         void vnonote(firstNote, BENDCENTER+totalBendUnits, remainingTime, vsteps, velocity)
  278.         return(0)
  279.     end
  280.     # tie note for remaining time
  281.     tie  remainingTime
  282. #     void printf("bend %d \n",BENDCENTER)
  283.     # issue rest to make sure noteoff in effect. this
  284.     # is paranoia most likely
  285.     rest 0
  286.     # put pitchbend wheel at center
  287.     bend 0 BENDCENTER
  288. #    void dumptime()
  289. end
  290.  
  291. #
  292. # bend Down requested interval
  293. #
  294. # interval 0..12: max range an octave
  295. riff bendDown(firstNote, firstTime, bendTime, totalTime, interval, velocity, vflag, vsteps)
  296. # interval - number of semitones to bend up
  297.     int events
  298.     int bendIncrement
  299.     int totalBendUnits
  300.     int pertimeClick
  301.     int curincrement
  302.     int bendvalue
  303.     int elapsedTime
  304.     int remainingTime
  305.  
  306.     # make sure pitch bend offset is set at 1 so
  307.     # that we use the true MIDI numbers in decimal
  308.     poff 1
  309.  
  310.     # don't set interval to 0
  311.     if (interval == 0)
  312.         void printf("bendUp: invalid 0 interval\n")
  313.         final
  314.     end
  315.     # total number of bend units to cover interval
  316.     totalBendUnits = interval * SEMITONEUNITS
  317.  
  318.     # determine per bend event time and how much
  319.     # to bend per bend call
  320.     # if more time than total bend units according
  321.     # to the interval, then divide the time
  322.     # by the number of bend units to get the per
  323.     # bend call time, otherwise time is 1
  324.     if (bendTime > totalBendUnits)
  325.         pertimeClick = bendTime / totalBendUnits
  326.         bendIncrement = totalBendUnits / pertimeClick
  327.     else
  328.         bendIncrement = totalBendUnits / bendTime
  329.         pertimeClick = 1
  330.     end
  331.  
  332. #     void printf("bendIncrement %d\n",bendIncrement)
  333. #     void printf("pertimeClick %d\n",pertimeClick)
  334. #     void printf("totalBendUnits %d\n",totalBendUnits)
  335.  
  336.     # play note with 0 eventime    
  337.     # the note lasts "totalTime" time before a noteoff
  338.     # is issued
  339.     note firstNote    firstTime, totalTime        velocity
  340. #    void dumptime()
  341.     bendvalue = BENDCENTER
  342.     # start off with pitch bend wheel centered
  343.     # take no time to do this
  344.     poff 1
  345.     bend    0    BENDCENTER
  346.     curincrement = bendIncrement
  347.     # loop through pitch bend up
  348.     elapsedTime = 0
  349.     for ( events = 0; events < bendTime; events++)
  350.         bend pertimeClick BENDCENTER-curincrement 
  351. #        void printf("%d %d\n",pertimeClick,BENDCENTER+curincrement)
  352.         curincrement = curincrement + bendIncrement
  353.         elapsedTime = elapsedTime + pertimeClick
  354.     end
  355.     # issue another pitch bend to make sure we
  356.     # arrived where we want because for loop
  357.     # above may not have arrived precisely
  358.     bend 0    BENDCENTER - totalBendUnits
  359. #    void printf("%d \n",BENDCENTER+totalBendUnits)
  360.     # use bend constant to return pitchbend wheel to center
  361.     poff 1
  362.     # deterime amount of eventtime remaining
  363.     # we may have some slop if the amount of time
  364.     # spent playing bends did not equal the bendTime
  365.     if (elapsedTime == bendTime)
  366.         remainingTime = totalTime - {firstTime + bendTime}
  367.     else
  368.         remainingTime = {bendTime - elapsedTime} + {totalTime - {bendTime + firstTime}}
  369.     end
  370.     # do vibratto for last half
  371.     # use special vibratto routine that does not issue note
  372.     # just bends
  373.     if (vflag)
  374.         void vnonote(firstNote, BENDCENTER-totalBendUnits, remainingTime, vsteps, velocity)
  375.         return(0)
  376.     end
  377.     # tie note for remaining time
  378.     tie  remainingTime
  379. #     void printf("bend %d \n",BENDCENTER)
  380.     # issue rest to make sure noteoff in effect. this
  381.     # is paranoia most likely
  382.     rest 0
  383.     # put pitchbend wheel at center
  384.     bend 0 BENDCENTER
  385. #    void dumptime()
  386. end
  387.  
  388. #
  389. # bendUpDown
  390. #
  391. # bend up interval requested
  392. # then bend down
  393. #
  394. riff bendUpDown(firstNote, firstTime, bendTime, totalTime, interval, velocity, vflag, vsteps)
  395. # interval - number of semitones to bend up
  396.     int events
  397.     int bendIncrement
  398.     int totalBendUnits
  399.     int pertimeClick
  400.     int curincrement
  401.     int bendvalue
  402.     int elapsedTime
  403.     int remainingTime
  404.     int firstHalf    # first half of time delta
  405.     int secondHalf    # second half of time delta
  406.  
  407.     # make sure pitch bend offset is set at 1 so
  408.     # that we use the true MIDI numbers in decimal
  409.     poff 1
  410.  
  411.     # don't set interval to 0
  412.     if (interval == 0)
  413.         void printf("bendUp: invalid 0 interval\n")
  414.         final
  415.     end
  416.  
  417.     # split bend timedelta into first half and second
  418.     # half and make sure all events are accounted for
  419.     # in time
  420.     firstHalf = bendTime >> 1
  421.     if ({bendTime % 2} != 0)
  422.         secondHalf = firstHalf + 1
  423.     else
  424.         secondHalf = firstHalf
  425.     end
  426.  
  427.     # total number of bend units to cover interval
  428.     totalBendUnits = interval * SEMITONEUNITS
  429.  
  430.     # determine per bend event time and how much
  431.     # to bend per bend call
  432.     # if more time than total bend units according
  433.     # to the interval, then divide the time
  434.     # by the number of bend units to get the per
  435.     # bend call time, otherwise time is 1
  436.     if (firstHalf > totalBendUnits)
  437.         pertimeClick = firstHalf / totalBendUnits
  438.         bendIncrement = totalBendUnits / pertimeClick
  439.     else
  440.         bendIncrement = totalBendUnits / firstHalf
  441.         pertimeClick = 1
  442.     end
  443.  
  444. #     void printf("bendIncrement %d\n",bendIncrement)
  445. #     void printf("pertimeClick %d\n",pertimeClick)
  446. #     void printf("totalBendUnits %d\n",totalBendUnits)
  447.  
  448.     # play note with 0 eventime    
  449.     # the note lasts "totalTime" time before a noteoff
  450.     # is issued
  451.     note firstNote    firstTime,totalTime        velocity
  452. #    void dumptime()
  453.     bendvalue = BENDCENTER
  454.     # start off with pitch bend wheel centered
  455.     # take no time to do this
  456.     poff 1
  457.     bend    0    BENDCENTER
  458.     curincrement = bendIncrement
  459.     # loop through pitch bend up
  460.     elapsedTime = 0
  461.     for ( events = 0; events < firstHalf; events++)
  462.         bend pertimeClick BENDCENTER+curincrement 
  463. #        void printf("%d %d\n",pertimeClick,BENDCENTER+curincrement)
  464.         curincrement = curincrement + bendIncrement
  465.         elapsedTime = elapsedTime + pertimeClick
  466.     end
  467.  
  468.     # make sure we got to top
  469.     bend 0    BENDCENTER + totalBendUnits
  470.     curincrement = totalBendUnits
  471.  
  472.     # now loop down, keep running totals
  473.     for ( events = 0; events < secondHalf; events++)
  474.         bend pertimeClick BENDCENTER+curincrement
  475. #        void printf("%d %d\n",pertimeClick,BENDCENTER+curincrement)
  476.         curincrement = curincrement - bendIncrement
  477.         elapsedTime = elapsedTime + pertimeClick
  478.     end
  479.  
  480.     # issue another pitch bend to make sure we
  481.     # arrived where we want because for loop
  482.     # above may not have arrived precisely
  483.     bend 0    BENDCENTER 
  484.  
  485. #    void printf("%d \n",BENDCENTER+totalBendUnits)
  486.     # use bend constant to return pitchbend wheel to center
  487.     poff 1
  488.     # deterime amount of eventtime remaining
  489.     # we may have some slop if the amount of time
  490.     # spent playing bends did not equal the bendTime
  491.     if (elapsedTime == bendTime)
  492.         remainingTime = totalTime - {firstTime + bendTime}
  493.     else
  494.         remainingTime = {bendTime - elapsedTime} + {totalTime - {bendTime + firstTime}}
  495.     end
  496.     if (vflag)
  497.         void vnonote(firstNote, BENDCENTER, remainingTime, vsteps, velocity)
  498.         return(0)
  499.     end
  500.  
  501.     # tie note for remaining time
  502.     tie  remainingTime
  503. #     void printf("bend %d \n",BENDCENTER)
  504.     # issue rest to make sure noteoff in effect. this
  505.     # is paranoia most likely
  506.     rest 0
  507.     # put pitchbend wheel at center
  508.     bend 0 BENDCENTER
  509. #    void dumptime()
  510. end
  511.  
  512.  
  513. # should start with 4 note chord from LLC to LC range
  514. # LLC, LE, LG, LC to LC, E, G, HC octave bend. Fun.
  515. # then play major scale via bends twice.
  516. # finish off with normal C to HC for contrast
  517. #
  518. riff testBendUp()
  519.     int i
  520.     void printf("C chord bend up\n")
  521.     LG    0,w
  522.     LE    0,w
  523.     LLC    0,w
  524.     void bendUp(LC, 0, h, w, 12, 100, 0, 0)
  525.     void printf("C scale down twice\n")
  526.     for ( i = 0; i < 2; i++)
  527.         C    q
  528.         # up to D
  529.         void bendUp(C, 0, e, q, 2, 100, 0, 0)
  530.         # up to E
  531.         void bendUp(D, 0, e, q, 2, 100, 0, 0)
  532.         # up to F
  533.         void bendUp(E, 0, e, q, 1, 100, 0, 0)
  534.         void bendUp(F, 0, e, q, 2, 100, 0, 0)
  535.         void bendUp(G, 0, e, q, 2, 100, 0, 0)
  536.         void bendUp(A, 0, e, q, 2, 100, 0, 0)
  537.         void bendUp(B, 0, e, q, 1, 100, 0, 0)
  538.     end
  539.     void printf("C HC reference tones\n")
  540.     C    q
  541.     HC    q
  542.  
  543. end
  544.  
  545. riff testBendDown()
  546.     void printf("bend down: C scale down to G\n")
  547.     # C
  548.     note C    q    127
  549.     # C to LB
  550.     void bendDown(C, 0, e, q, 1, 127, 0, 0)
  551.     # LB to LA
  552.     void bendDown(LB, 0, e, q, 2, 127, 0, 0)
  553.     # LA to LG
  554.     void printf("bend down: LG scale down to LC\n")
  555.     void bendDown(LA, 0, e, q, 2, 127, 0, 0)
  556.     # LG to LC
  557.     void bendDown(LG, 0, e, q, 7, 127, 0, 0)
  558.  
  559.  
  560.     void printf("C then C to LC\n")
  561.     C    q
  562.     void bendDown(C, 0, q, w, 12, 127, 0, 0) 
  563.     #
  564.     void printf("reference tones LC C \n")
  565.     LC    q
  566.     C    q
  567. end
  568.  
  569. riff testVibratto()
  570.     int vsteps
  571.     int i
  572.     vsteps = 0
  573.     for ( i = 0 ; i < 20; i++)
  574.         void printf("vsteps %d\n",vsteps)
  575.         void vibratto(C, q*3, w, vsteps, 100)
  576.         vsteps = vsteps + 10
  577.     end
  578. end
  579.  
  580. riff testguitarRiff()
  581.     void bendUp(LG, 2, e+2, q, 2, 110, 1, 70)
  582.  
  583.     void vibratto(LA, q,q, 80, 100)
  584.     void vibratto(E, q,q, 60, 100)
  585.     void bendUpDown(D, 3, q+e-3, q+e, 2, 110, 0, 0)
  586.     void vibratto(C, e, e, 50, 100)
  587.     void vibratto(LA, 3*q,3*q, 110, 100)
  588.     rest    e
  589.     void bendUp(LG, 0, e, q+e, 2, 110, 1, 110)
  590. end
  591.  
  592. riff testBendLib()
  593.     void testguitarRiff()
  594.     void testBendUp()
  595.     void testBendDown()
  596.     void testVibratto()
  597. end
  598.